Cómo informar de forma eficiente las ventanas correderas con una longitud fija en segundos

Creo que te refieres al incremento basado en "Para cada ventana de duración de 2 segundos comenzando en un segundo límite" y no superpuesto. Para intervalos de dos segundos, es lo mismo, pero como desea variar la longitud, una superposición de un segundo sería 0-3, 2-5, 4-7, pero el incremento significaría 0-3, 1-4, 2- 5. Sin embargo, fue interesante encontrar soluciones para ambos por si acaso.
Suponiendo que L está ordenado y todos los elementos son positivos y los segundos intervalos comienzan con números enteros, podemos usar este método:
importar matemáticas
de las colecciones importar defaultdict
L = [0.10218048, 1.20851996, 1.46800021, 1.73429061, 2.71525848,
3.14781922, 3.63637958, 5.11147358, 5.97497864, 6.35469013,
6.80623747, 6.99571917, 7.65215123, 7.86108352, 8.52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
my_ranges = defaultdict (lista)
intervalo_ancho = 2
para x en L:
Upper_bound = math.ceil (x)
lower_bound = upper_bound - intervalo_ancho
límite_inferior = max (0, límite_inferior)
para y en el rango (límite inferior, límite superior):
mis_rangos [y] .append (x)
para un ordenado (my_ranges):
imprimir (mis_rangos [a])
No sé si quiere ver si hay rangos vacíos. Pero el defaultdict también imprime rangos vacíos si lo desea. Utilice esta línea en lugar de "para un ordenado":
para un en rango (min (my_ranges), max (my_ranges) + 1):
Si desea los rangos 0-3, 2-5, 4-7, esto funciona:
importar matemáticas
de las colecciones importar defaultdict
L = [0.10218048, 1.20851996, 1.46800021, 1.73429061, 2.71525848,
3.14781922, 3.63637958, 5.11147358, 5.97497864, 6.35469013,
6.80623747, 6.99571917, 7.65215123, 7.86108352, 8.52988247,
8.83068894, 10.07690977, 11.53867284, 12.01214112, 12.13307653]
intervalo_ancho = 2
my_ranges_2 = defaultdict (lista)
para x en L:
definitivamente_en = (x // (intervalo_width - 1)) * (intervalo_width - 1) # múltiplo más bajo de intervalo_width debajo de x siempre estará
#print ("Agregando", x, "a", definitivamente_en)
my_ranges_2 [definitivamente_en] .append (x)
si x  = 0: # por ejemplo, si x es 2.3 y tenemos 0,3 2,5 etc. ... necesitamos capturar este caso duplicado. Supongo que las longitudes de las ventanas son números enteros, y si no, tenemos mucho más que hacer, porque el número puede ir en más de una matriz. Quizás podríamos tener un ciclo while, incrementándose en (interval_width - 1)
#print ("++ Agregar", x, "a", definitivamente_en - intervalo_ancho + 1)
my_ranges_2 [definitivamente_en - intervalo_ancho + 1] .append (x)
para un ordenado (my_ranges_2):
imprimir (a, mis_rangos_2 [a])
# print (my_ranges_2 [a])
Sospecho que hay algunos detalles que he olvidado, pero espero que pueda girar interval_width según sea necesario para asegurarse de que mi código esté haciendo lo que esperaba y hacerme saber exactamente qué necesita.
|
Una posible solución que puedo proponer es "eficiente" en cierto sentido, que itera solo una vez a través de los datos de entrada y no tiene dependencias. El costo, por supuesto, es que está escrito en Python puro (puede haber un código más optimizado) y que introduce más variables de seguimiento para evitar la reiteración (y por lo tanto es menos pitónico).
def ventana_deslizante (datos, duración, inicio = 0, superposición = 1):
resultado = []
data_idx = 0
result_idx = 0
superior = inicio + duración
inferior = inicio
next_lower = upper - superposición
# ayudante interno para rellenar listas internas vacías hasta nuestro punto de inserción e insertar
def pad_and_append (en):
while len (resultado) <= en:
result.append ([])
resultado [en] .append (datos [data_idx])
# iterar a través de los datos de entrada
while data_idx  a:
si x  = l [0]) & (L  = i) & (L